Capstone - Complete Analytics System

# Analyzing Leicester's 2015-16 season efficiency
import pandas as pd

# Leicester's key stats from that season
leicester_stats = {
    'matches': 38,
    'goals_scored': 68,
    'goals_conceded': 36,
    'xG_for': 55.4,  # Expected goals created
    'xG_against': 42.1,  # Expected goals conceded
    'possession_avg': 42.3,  # Below league average!
    'points': 81
}

# Calculate overperformance
xg_difference = leicester_stats['goals_scored'] - leicester_stats['xG_for']
xga_difference = leicester_stats['xG_against'] - leicester_stats['goals_conceded']

print(f"Goals vs xG: +{xg_difference:.1f} (clinical finishing)")
print(f"Conceded vs xGA: -{xga_difference:.1f} (excellent defending)")
print(f"Net xG overperformance: +{xg_difference + xga_difference:.1f}")

# This shows Leicester massively outperformed their underlying numbers
# They scored 12.6 more goals than expected and conceded 6.1 fewer

# Exploring event data structure with StatsBomb
from statsbombpy import sb
import pandas as pd

# Load a match - 2022 World Cup Final
events = sb.events(match_id=3869685)

# See what columns are available
print("Event data columns:")
print(events.columns.tolist()[:20])  # First 20 columns

# Count events by type
print("\nEvent types in the match:")
print(events['type'].value_counts().head(15))

# Example: Look at a single pass event
pass_event = events[events['type'] == 'Pass'].iloc[0]
print("\nSample pass event:")
print(f"  Player: {pass_event['player']}")
print(f"  Team: {pass_event['team']}")
print(f"  Location: {pass_event['location']}")
print(f"  Pass end location: {pass_event['pass_end_location']}")
print(f"  Pass recipient: {pass_event['pass_recipient']}")
print(f"  Minute: {pass_event['minute']}")

# Accessing aggregate stats from FBref
import soccerdata as sd

# Initialize FBref scraper
fbref = sd.FBref(leagues="ENG-Premier League", seasons="2023-2024")

# Get player season stats
player_stats = fbref.read_player_season_stats(stat_type="standard")

# Look at top scorers
top_scorers = player_stats.nlargest(10, ('Performance', 'Gls'))
print("Top 10 Premier League Scorers 2023-24:")
print(top_scorers[['Performance', 'Gls', 'xG', 'npxG']].head(10))

# Calculate goals vs xG for top scorers
top_scorers['xG_diff'] = top_scorers[('Performance', 'Gls')] - top_scorers[('Expected', 'xG')]
print("\nGoals minus xG (overperformance):")
print(top_scorers[['xG_diff']].head(10))

from statsbombpy import sb
import pandas as pd
import matplotlib.pyplot as plt

# Load World Cup 2022 matches
competitions = sb.competitions()
world_cup = competitions[
    (competitions['competition_name'] == 'FIFA World Cup') &
    (competitions['season_name'] == '2022')
]

# Get all matches
matches = sb.matches(competition_id=43, season_id=106)
print(f"Total World Cup 2022 matches: {len(matches)}")

# Find the final
final = matches[matches['match_id'] == 3869685].iloc[0]
print(f"\nFinal: {final['home_team']} vs {final['away_team']}")
print(f"Score: {final['home_score']} - {final['away_score']}")

# Load all events from the final
events = sb.events(match_id=3869685)
print(f"\nTotal events in match: {len(events)}")

# Filter for shots only
shots = events[events['type'] == 'Shot'].copy()
print(f"Total shots in the match: {len(shots)}")

# Calculate shot statistics by team
shot_stats = shots.groupby('team').agg(
    total_shots=('type', 'count'),
    goals=('shot_outcome', lambda x: (x == 'Goal').sum()),
    total_xG=('shot_statsbomb_xg', 'sum'),
    shots_on_target=('shot_outcome', lambda x: x.isin(['Goal', 'Saved']).sum()),
    avg_xG_per_shot=('shot_statsbomb_xg', 'mean')
).round(2)

print("\n=== Shot Analysis: World Cup 2022 Final ===")
print(shot_stats)

# Calculate xG difference (goals - xG)
for team in shot_stats.index:
    goals = shot_stats.loc[team, 'goals']
    xG = shot_stats.loc[team, 'total_xG']
    diff = goals - xG
    print(f"\n{team}: {goals} goals from {xG:.2f} xG ({'+' if diff > 0 else ''}{diff:.2f})")

from mplsoccer import VerticalPitch
import matplotlib.pyplot as plt

# Extract shot coordinates
shots['x'] = shots['location'].apply(lambda loc: loc[0])
shots['y'] = shots['location'].apply(lambda loc: loc[1])
shots['is_goal'] = shots['shot_outcome'] == 'Goal'

# Create figure with two pitches (one per team)
fig, axes = plt.subplots(1, 2, figsize=(16, 10))

teams = ['Argentina', 'France']
colors = {'Argentina': '#75AADB', 'France': '#002654'}

for idx, team in enumerate(teams):
    pitch = VerticalPitch(
        pitch_type='statsbomb',
        half=True,
        pitch_color='#22312b',
        line_color='white'
    )
    pitch.draw(ax=axes[idx])

    team_shots = shots[shots['team'] == team]

    # Plot non-goals
    non_goals = team_shots[~team_shots['is_goal']]
    pitch.scatter(
        non_goals['x'], non_goals['y'],
        s=non_goals['shot_statsbomb_xg'] * 500 + 50,
        c=colors[team], alpha=0.5,
        edgecolors='white', linewidth=1,
        ax=axes[idx], label='Shot'
    )

    # Plot goals
    goals = team_shots[team_shots['is_goal']]
    pitch.scatter(
        goals['x'], goals['y'],
        s=goals['shot_statsbomb_xg'] * 500 + 50,
        c='#FFD700', alpha=1,
        edgecolors='white', linewidth=2,
        marker='*', ax=axes[idx], label='Goal'
    )

    # Add title with stats
    team_xg = team_shots['shot_statsbomb_xg'].sum()
    team_goals = team_shots['is_goal'].sum()
    axes[idx].set_title(
        f"{team}\n{team_goals} Goals | {team_xg:.2f} xG",
        fontsize=14, fontweight='bold', color='white'
    )
    axes[idx].legend(loc='lower right')

plt.suptitle('World Cup 2022 Final - Shot Map', fontsize=16, fontweight='bold', y=1.02)
fig.patch.set_facecolor('#22312b')
plt.tight_layout()
plt.savefig('world_cup_final_shots.png', dpi=150, bbox_inches='tight',
            facecolor='#22312b', edgecolor='none')
plt.show()

from statsbombpy import sb
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

# Load World Cup Final data
events = sb.events(match_id=3869685)
shots = events[events["type"] == "Shot"].copy()

# Create xG timeline data
shots = shots.sort_values(["minute", "second"])
shots["is_goal"] = shots["shot_outcome"] == "Goal"

# Calculate cumulative xG for each team
argentina_shots = shots[shots["team"] == "Argentina"].copy()
france_shots = shots[shots["team"] == "France"].copy()

argentina_shots["cumulative_xG"] = argentina_shots["shot_statsbomb_xg"].cumsum()
france_shots["cumulative_xG"] = france_shots["shot_statsbomb_xg"].cumsum()

# Create the plot
fig, ax = plt.subplots(figsize=(14, 7))

# Starting points
ax.plot([0], [0], "o", color="#75AADB", markersize=0)
ax.plot([0], [0], "o", color="#002654", markersize=0)

# Argentina xG line (step plot)
arg_minutes = [0] + argentina_shots["minute"].tolist()
arg_xg = [0] + argentina_shots["cumulative_xG"].tolist()
ax.step(arg_minutes, arg_xg, where="post", linewidth=2.5,
        color="#75AADB", label="Argentina", alpha=0.9)

# France xG line
fra_minutes = [0] + france_shots["minute"].tolist()
fra_xg = [0] + france_shots["cumulative_xG"].tolist()
ax.step(fra_minutes, fra_xg, where="post", linewidth=2.5,
        color="#002654", label="France", alpha=0.9)

# Mark goals with stars
arg_goals = argentina_shots[argentina_shots["is_goal"]]
fra_goals = france_shots[france_shots["is_goal"]]

ax.scatter(arg_goals["minute"], arg_goals["cumulative_xG"],
           marker="*", s=300, color="#75AADB", edgecolors="gold",
           linewidth=2, zorder=5)
ax.scatter(fra_goals["minute"], fra_goals["cumulative_xG"],
           marker="*", s=300, color="#002654", edgecolors="gold",
           linewidth=2, zorder=5)

# Add period markers
ax.axvline(x=45, color="gray", linestyle="--", alpha=0.5)
ax.axvline(x=90, color="gray", linestyle="--", alpha=0.5)
ax.axvline(x=105, color="gray", linestyle=":", alpha=0.5)
ax.text(45, ax.get_ylim()[1], "HT", ha="center", fontsize=9)
ax.text(90, ax.get_ylim()[1], "FT", ha="center", fontsize=9)
ax.text(105, ax.get_ylim()[1], "ET", ha="center", fontsize=9)

# Styling
ax.set_xlabel("Minute", fontsize=12)
ax.set_ylabel("Cumulative xG", fontsize=12)
ax.set_title("xG Timeline: World Cup 2022 Final\nArgentina 3-3 France",
             fontsize=14, fontweight="bold")
ax.legend(loc="upper left", fontsize=11)
ax.set_xlim(0, 125)
ax.set_ylim(0, max(arg_xg[-1], fra_xg[-1]) + 0.5)
ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig("xg_timeline.png", dpi=150, bbox_inches="tight")
plt.show()

from statsbombpy import sb
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

# Load match data
events = sb.events(match_id=3869685)
passes = events[events["type"] == "Pass"].copy()

# Calculate passing statistics by team
def calc_pass_stats(team_passes):
    return {
        "Total Passes": len(team_passes),
        "Completion %": (team_passes["pass_outcome"].isna().sum() / len(team_passes)) * 100,
        "Progressive": team_passes["pass_progressive"].sum() if "pass_progressive" in team_passes else 0,
        "Final Third": (team_passes["pass_end_location"].apply(
            lambda x: x[0] > 80 if isinstance(x, list) else False
        ).sum()),
        "Key Passes": (team_passes["pass_shot_assist"].fillna(False).sum() +
                       team_passes["pass_goal_assist"].fillna(False).sum())
    }

argentina_stats = calc_pass_stats(passes[passes["team"] == "Argentina"])
france_stats = calc_pass_stats(passes[passes["team"] == "France"])

# Prepare data for plotting
metrics = list(argentina_stats.keys())
arg_values = list(argentina_stats.values())
fra_values = list(france_stats.values())

# Create grouped bar chart
x = np.arange(len(metrics))
width = 0.35

fig, ax = plt.subplots(figsize=(14, 7))

bars1 = ax.bar(x - width/2, arg_values, width, label="Argentina",
               color="#75AADB", edgecolor="white", linewidth=1.5)
bars2 = ax.bar(x + width/2, fra_values, width, label="France",
               color="#002654", edgecolor="white", linewidth=1.5)

# Add value labels on bars
def add_labels(bars):
    for bar in bars:
        height = bar.get_height()
        ax.annotate(f"{height:.1f}",
                    xy=(bar.get_x() + bar.get_width() / 2, height),
                    xytext=(0, 3),
                    textcoords="offset points",
                    ha="center", va="bottom", fontsize=10)

add_labels(bars1)
add_labels(bars2)

# Styling
ax.set_xlabel("Metric", fontsize=12)
ax.set_ylabel("Value", fontsize=12)
ax.set_title("Passing Comparison: World Cup 2022 Final\n" +
             "Argentina dominated possession but France remained dangerous",
             fontsize=14, fontweight="bold")
ax.set_xticks(x)
ax.set_xticklabels(metrics, fontsize=11)
ax.legend(fontsize=11)
ax.grid(axis="y", alpha=0.3)
ax.set_axisbelow(True)

plt.tight_layout()
plt.savefig("passing_comparison.png", dpi=150, bbox_inches="tight")
plt.show()

from statsbombpy import sb
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
from math import pi

# Load match data
events = sb.events(match_id=3869685)

# Filter for Messi and Mbappe
players = ["Lionel Andrés Messi Cuccittini", "Kylian Mbappé Lottin"]
player_events = events[events["player"].isin(players)]

# Calculate stats for each player
def calc_player_stats(player_name, all_events):
    pe = all_events[all_events["player"] == player_name]
    shots = pe[pe["type"] == "Shot"]
    passes = pe[pe["type"] == "Pass"]
    dribbles = pe[pe["type"] == "Dribble"]

    return {
        "Shots": len(shots),
        "xG": shots["shot_statsbomb_xg"].sum(),
        "Goals": (shots["shot_outcome"] == "Goal").sum(),
        "Key Passes": (passes["pass_shot_assist"].fillna(False).sum() +
                       passes["pass_goal_assist"].fillna(False).sum()),
        "Dribbles": (dribbles["dribble_outcome"] == "Complete").sum(),
        "Touches": len(pe)
    }

messi_stats = calc_player_stats(players[0], events)
mbappe_stats = calc_player_stats(players[1], events)

# Normalize to percentages (max across both players = 100)
categories = list(messi_stats.keys())
messi_values = list(messi_stats.values())
mbappe_values = list(mbappe_stats.values())

# Normalize
max_values = [max(m, mb) for m, mb in zip(messi_values, mbappe_values)]
messi_norm = [v/mx*100 if mx > 0 else 0 for v, mx in zip(messi_values, max_values)]
mbappe_norm = [v/mx*100 if mx > 0 else 0 for v, mx in zip(mbappe_values, max_values)]

# Create radar chart
fig, ax = plt.subplots(figsize=(10, 10), subplot_kw=dict(polar=True))

# Calculate angles for each category
angles = [n / float(len(categories)) * 2 * pi for n in range(len(categories))]
angles += angles[:1]  # Complete the loop

# Add data (closing the loop)
messi_norm += messi_norm[:1]
mbappe_norm += mbappe_norm[:1]

# Plot
ax.plot(angles, messi_norm, "o-", linewidth=2.5, color="#75AADB", label="Messi")
ax.fill(angles, messi_norm, alpha=0.25, color="#75AADB")

ax.plot(angles, mbappe_norm, "o-", linewidth=2.5, color="#002654", label="Mbappé")
ax.fill(angles, mbappe_norm, alpha=0.25, color="#002654")

# Set category labels
ax.set_xticks(angles[:-1])
ax.set_xticklabels(categories, fontsize=12)

# Add actual values as annotations
for i, (angle, m_val, mb_val) in enumerate(zip(angles[:-1], messi_values, mbappe_values)):
    ax.annotate(f"{m_val:.1f}", xy=(angle, messi_norm[i]+8),
                ha="center", fontsize=9, color="#75AADB")
    ax.annotate(f"{mb_val:.1f}", xy=(angle, mbappe_norm[i]-12),
                ha="center", fontsize=9, color="#002654")

ax.set_title("Messi vs Mbappé\nWorld Cup 2022 Final Performance",
             fontsize=14, fontweight="bold", y=1.08)
ax.legend(loc="upper right", bbox_to_anchor=(1.15, 1.1), fontsize=11)

plt.tight_layout()
plt.savefig("player_radar.png", dpi=150, bbox_inches="tight")
plt.show()

# Print raw stats
print("\nRaw Statistics:")
print(f"Messi: {messi_stats}")
print(f"Mbappé: {mbappe_stats}")

from statsbombpy import sb
import pandas as pd
import matplotlib.pyplot as plt
from mplsoccer import Pitch, VerticalPitch
import numpy as np
from scipy.stats import gaussian_kde

# Load match data
events = sb.events(match_id=3869685)

# Get Messi events with location
messi_events = events[events["player"].str.contains("Messi", na=False)].copy()
messi_events = messi_events[messi_events["location"].notna()]

# Extract x, y coordinates
messi_events["x"] = messi_events["location"].apply(lambda loc: loc[0])
messi_events["y"] = messi_events["location"].apply(lambda loc: loc[1])

# Create pitch
pitch = Pitch(pitch_type="statsbomb", pitch_color="#22312b",
              line_color="white", linewidth=1)
fig, ax = pitch.draw(figsize=(12, 8))

# Create heat map using kernel density estimation
pitch.kdeplot(
    messi_events["x"], messi_events["y"],
    ax=ax,
    cmap="YlOrRd",
    shade=True,
    shade_lowest=False,
    n_levels=25,
    alpha=0.7
)

# Add scatter points
pitch.scatter(
    messi_events["x"], messi_events["y"],
    ax=ax,
    s=20, color="white", alpha=0.3, edgecolors="none"
)

ax.set_title("Messi Touch Heat Map - World Cup 2022 Final\n" +
             "Density of all touches throughout the match",
             fontsize=14, fontweight="bold", color="white", y=1.02)

fig.patch.set_facecolor("#22312b")
plt.tight_layout()
plt.savefig("messi_heatmap.png", dpi=150, bbox_inches="tight",
            facecolor="#22312b", edgecolor="none")
plt.show()