Race Strategy Examples

from matplotlib import pyplot as plt
import fastf1
import fastf1.plotting

# Load the race session
session = fastf1.get_session(2022, "Hungary", 'R')
session.load()
laps = session.laps

# Get the list of drivers and convert to abbreviations
drivers = session.drivers
drivers = [session.get_driver(driver)["Abbreviation"] for driver in drivers]
print(drivers)

# Find the stint length and compound used for every stint by every driver
# Group by driver, stint number, and compound, then count laps
stints = laps[["Driver", "Stint", "Compound", "LapNumber"]]
stints = stints.groupby(["Driver", "Stint", "Compound"])
stints = stints.count().reset_index()

# Rename LapNumber column to StintLength
stints = stints.rename(columns={"LapNumber": "StintLength"})
print(stints)

# Plot the strategies for each driver
fig, ax = plt.subplots(figsize=(5, 10))

for driver in drivers:
    driver_stints = stints.loc[stints["Driver"] == driver]
    
    previous_stint_end = 0
    for idx, row in driver_stints.iterrows():
        # Each row contains the compound name and stint length
        # Use these to draw horizontal bars
        compound_color = fastf1.plotting.get_compound_color(row["Compound"],
                                                            session=session)
        plt.barh(
            y=driver,
            width=row["StintLength"],
            left=previous_stint_end,
            color=compound_color,
            edgecolor="black",
            fill=True
        )
        
        previous_stint_end += row["StintLength"]

# Make the plot more readable
plt.title("2022 Hungarian Grand Prix Strategies")
plt.xlabel("Lap Number")
plt.grid(False)
# Invert y-axis so drivers that finish higher are closer to the top
ax.invert_yaxis()

# Plot aesthetics
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.spines['left'].set_visible(False)

plt.tight_layout()
plt.show()

import matplotlib.pyplot as plt
import fastf1.plotting

fastf1.plotting.setup_mpl(mpl_timedelta_support=False, color_scheme='fastf1')

# Load the session
session = fastf1.get_session(2023, 1, 'R')
session.load(telemetry=False, weather=False)

fig, ax = plt.subplots(figsize=(8.0, 4.9))

# For each driver, plot their position over the laps
for drv in session.drivers:
    drv_laps = session.laps.pick_drivers(drv)
    
    abb = drv_laps['Driver'].iloc[0]
    style = fastf1.plotting.get_driver_style(identifier=abb,
                                             style=['color', 'linestyle'],
                                             session=session)
    
    ax.plot(drv_laps['LapNumber'], drv_laps['Position'],
            label=abb, **style)

# Finalize the plot
ax.set_ylim([20.5, 0.5])
ax.set_yticks([1, 5, 10, 15, 20])
ax.set_xlabel('Lap')
ax.set_ylabel('Position')

# Add legend outside the plot area
ax.legend(bbox_to_anchor=(1.0, 1.02))
plt.tight_layout()

plt.show()

# For position analysis, skip telemetry and weather data
session.load(telemetry=False, weather=False)

import matplotlib.pyplot as plt
import pandas as pd
from timple.timedelta import strftimedelta
import fastf1
import fastf1.plotting
from fastf1.core import Laps

fastf1.plotting.setup_mpl(mpl_timedelta_support=True, color_scheme=None)

session = fastf1.get_session(2021, 'Spanish Grand Prix', 'Q')
session.load()

# Get an array of all drivers
drivers = pd.unique(session.laps['Driver'])
print(drivers)

# Get each driver's fastest lap and create a sorted list
list_fastest_laps = list()
for drv in drivers:
    drvs_fastest_lap = session.laps.pick_drivers(drv).pick_fastest()
    list_fastest_laps.append(drvs_fastest_lap)

fastest_laps = Laps(list_fastest_laps) \
    .sort_values(by='LapTime') \
    .reset_index(drop=True)

# Calculate time delta from pole position
pole_lap = fastest_laps.pick_fastest()
fastest_laps['LapTimeDelta'] = fastest_laps['LapTime'] - pole_lap['LapTime']

print(fastest_laps[['Driver', 'LapTime', 'LapTimeDelta']])

# Create a list of team colors per lap
team_colors = list()
for index, lap in fastest_laps.iterlaps():
    color = fastf1.plotting.get_team_color(lap['Team'], session=session)
    team_colors.append(color)

# Plot the data
fig, ax = plt.subplots()
ax.barh(fastest_laps.index, fastest_laps['LapTimeDelta'],
        color=team_colors, edgecolor='grey')
ax.set_yticks(fastest_laps.index)
ax.set_yticklabels(fastest_laps['Driver'])

# Show fastest at the top
ax.invert_yaxis()

# Draw vertical lines behind the bars
ax.set_axisbelow(True)
ax.xaxis.grid(True, which='major', linestyle='--', color='black', zorder=-1000)

# Add title with pole lap time
lap_time_string = strftimedelta(pole_lap['LapTime'], '%m:%s.%ms')
plt.suptitle(f"{session.event['EventName']} {session.event.year} Qualifying\n"
             f"Fastest Lap: {lap_time_string} ({pole_lap['Driver']})")

plt.show()

import seaborn as sns
from matplotlib import pyplot as plt
import fastf1
import fastf1.plotting

fastf1.plotting.setup_mpl(mpl_timedelta_support=False, color_scheme='fastf1')

# Load the race session and pick quick laps
race = fastf1.get_session(2024, 1, 'R')
race.load()
laps = race.laps.pick_quicklaps()

# Convert lap time to seconds
transformed_laps = laps.copy()
transformed_laps.loc[:, "LapTime (s)"] = laps["LapTime"].dt.total_seconds()

# Order teams from fastest to slowest (by median lap time)
team_order = (
    transformed_laps[["Team", "LapTime (s)"]]
    .groupby("Team")
    .median()["LapTime (s)"]
    .sort_values()
    .index
)
print(team_order)

# Create color palette for teams
team_palette = {team: fastf1.plotting.get_team_color(team, session=race)
                for team in team_order}

# Create box plot
fig, ax = plt.subplots(figsize=(15, 10))
sns.boxplot(
    data=transformed_laps,
    x="Team",
    y="LapTime (s)",
    hue="Team",
    order=team_order,
    palette=team_palette,
    whiskerprops=dict(color="white"),
    boxprops=dict(edgecolor="white"),
    medianprops=dict(color="grey"),
    capprops=dict(color="white"),
)

plt.title("2024 Bahrain Grand Prix - Team Pace Comparison")
plt.grid(visible=False)
ax.set(xlabel=None)
plt.tight_layout()
plt.show()

# Count pit stops per driver
pit_stops = stints.groupby('Driver').size() - 1  # Subtract 1 (initial stint)

# Most common strategy
common_strategy = stints.groupby(['Stint', 'Compound']).size()

# Average stint length by compound
avg_stint_length = stints.groupby('Compound')['StintLength'].mean()

# Compare two drivers' strategies
driver1_stints = stints[stints['Driver'] == 'VER']
driver2_stints = stints[stints['Driver'] == 'HAM']

print("VER stints:", driver1_stints[['Stint', 'Compound', 'StintLength']])
print("HAM stints:", driver2_stints[['Stint', 'Compound', 'StintLength']])