Motor Racing Trinity: F1, Python, and APIs

Formula One (F1) racing is not just about fast cars and skilled drivers. It's also about the data that fuels the sport. F1 has been a leader in providing data and transparency to its fans, and with the help of Python and APIs, fans can analyze that data like never before.

Enter the Holy Trinity: F1, Python, and APIs. The combination of these three elements has enabled fans (me in particular) to access and analyze F1 data in ways that were unimaginable to me before. In particular, the FastF1 API has is a powerful tool for F1 enthusiasts who want to dive deep into the world of F1 data.

With FastF1, fans can access a wealth of information, including lap times, telemetry data, and even weather conditions. By leveraging the power of Python, fans can take this data and turn it into meaningful insights and analyses.

the FastF1 API itself is obviously an unofficial software and not associated by F1, but the fact that F1 provides access to the vast amounts of data collected through a season which can be used by developers to build such API's is a remarkable thing in my opinion.

One example of this is the Fastest Lap analysis that we can perform using the FastF1 API. With this API, we can easily access lap data from any race in the current season, and use it to analyze driver performance and lap times.

Here's how it works for getting a visual representation of Fastest Lap of all drivers at the Saudi Grand Prox of 2023:

we start by importing the necessary Python libraries and enabling the cache directory for FastF1:

import matplotlib.pyplot as pl
import pandas as pd
import fastf1 as ff1
import fastf1.plotting
from fastf1.core import Laps
import datetimet        

# use your cache directory
ff1.Cache.enable_cache(../cache)        

Then we use the get_session function to retrieve the session data for the Spanish Grand Prix:

session = ff1.get_session(2023, 'Saudi Grand Prix', 'R')
session.load())        

Next, we pick out the drivers and their respective fastest laps:

drivers = pd.unique(session.laps['Driver']


list_fastest_laps = list()
for drv in drivers:
? ? drvs_fastest_lap = session.laps.pick_driver(drv).pick_fastest()
? ? list_fastest_laps.append(drvs_fastest_lap)


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

)        

We then calculate the pole lap time and the time delta for each lap:

pole_lap = fastest_laps.pick_fastest(
pole_lap_time = datetime.datetime(1,1,1,0,0,0) + pole_lap['LapTime']


fastest_laps['LapTimeDelta'] = fastest_laps['LapTime'] - pole_lap['LapTime'])        

And finally, we create a bar chart to display the lap time deltas for each driver:

team_colors = list(
for index, lap in fastest_laps.iterlaps():
? ? color = ff1.plotting.team_color(lap['Team'])
? ? team_colors.appe
d(color))
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)


# Title for the plot


# lap_time_string = pole_lap['LapTime'].strftime('%M:%S.%f')[:-3]
lap_time_string = pole_lap_time.strftime('%M:%S.%f')[:-3]
plt.suptitle(f"{session.event['EventName']} {session.event.year} Race\n"
? ? ? ? ? ? ?f"Fastest Lap: {lap_time_string} ({pole_lap['Driver']})")


plt.show()

        

This code allows us to easily analyze and visualize lap data for any race in the current season, providing valuable insights.