Data Science For Cycling — How To Read GPX Strava Routes With Python | by Dario Radečić | Towards Data Science

I love cycling, and I love using Strava to keep track of my training activities. As a data nerd, I’m a bit disappointed with their workout analysis. Sure, you can analyze speed, power, cadence, heart rate, and whatnot — depending on the sensors you have available — but what I really miss is a deep gradient analysis.
Now, a gradient in data science and cycling don’t necessarily represent the same thing. In cycling, it’s basically the slope of the surface you’re riding on. Being a tall and somewhat heavy rider I find hills challenging, so a deeper gradient analysis would be helpful. For example, I’d like to see how much distance I’ve covered between 3 and 5 percent grade, how much was above 10, and everything in between. You get the point.
Strava doesn’t offer that functionality, so I decided to do the calculations from scratch using my Python skills.
Join me in a 6 article mini-series that will kick of with a crash course in GPX file format and end in a dashboard that displays your training data in more depth than Strava.
Don’t feel like reading? Watch my video instead:
You can download the source code on GitHub.
Strava lets you export your workouts and routes in GPX file format. Put simply, GPX stands for GPS Exchange Format, and it’s nothing but a text file with geographical information, such as latitude, longitude, elevations, tracks, waypoints, and so on.
An exported Strava route GPX file has many points taken at different times, each containing latitude, longitude, and elevation. In simple terms, you know exactly where you were and what was your altitude. This is essential for calculating gradients and gradient ranges, which we’ll do in a couple of articles.
If you’re following along, head over to Strava and download any of your saved routes (Export GPX button):
Creating routes requires a paid Strava subscription, so for safety concerns I won’t share my GPX files with you. Use any GPX file from your routes or the training log. If you’re not using Strava, simply find a sample GPX file online, it should still work.
Got the GPX file ready? Awesome — let’s see how to read it with Python next.
You’ll need a dedicated gpxpy package to read GPX with Python. Install it with Pip:
pip install gpxpy
You can now launch Jupyter or any other code editor to get started. First things first, let’s get the library imports out of the way:
Use Python’s context manager syntax to read and parse a GPX file:
Please note you’ll have to change the path to match your system and GPX file name. If everything went well, you should have the file now available in Python.
But what’s inside? Let’s see:
It’s a specific GPX object with the track name and segment, where each segment contains data points (latitude, longitude, and elevation). We’ll dive deeper into these in the following section, but first, let’s explore a couple of useful functions.
For example, you can extract the total number of data points in a GPX file:
There are 835 points in total, each containing latitude, longitude, and elevation data. That will come useful later.
You can also get the altitude range:
In plain English, this means that the lowest point of the ride is 113,96 meters above sea level, while the highest is at 239,16 meters.
You can also extract the total meters of elevation gained and lost:
My route represents a roundtrip, so it’s expected to see identical or almost identical values. Lastly, you can display the contents of your GPX file in XML format:
It’s not super-readable, but it might come in handy if you have an XML processing pipeline.
And that does it for the basics. Next, you’ll see how to extract individual data points and convert them into a more readable format — Pandas DataFrame.
You can check how many tracks your GPX file has by running len(gpx.tracks). Mine has only one, and I can access it with Python’s list indexing notation:
We don’t care for the name of the track, as it’s arbitrary in this case. What we do care about are the segments. As with tracks, my GPX file has only one segment on this track. Here’s how to access it:
And now you can access individual data points by accessing the points array. Here are the first ten for my route:
That’s all we need to have some fun. You’ll now see how to extract individual data points from the GPX file:
It’s not the prettiest code you’ve ever seen, but gets the job done. Let’s print the first three entries to verify we did everything correctly:
Do you know what’s extra handy about a list of dictionaries? You can convert it to a Pandas DataFrame in a heartbeat:
You have to admit — that was pretty easy! We’ll need this dataset in the following articles, so let’s dump it into a CSV file:
That’s all for the basic analysis and preprocessing we’ll do today. I’ll also show you how to visualize this dataset with Matplotlib — just to see if we’re on the right track.
We’ll work on route visualization with Python and Folium in the following article, but today I want to show you how to make a basic visualization with Matplotlib. You won’t see the map, sure, but the location points should resemble the route from Image 1.
Hint: don’t go too wide with the figure size, as it would make the map look weird.
Copy the following code to visualize the route:
And who would tell — it’s identical to what we had in Image 1, not taking the obvious into account. You’ll learn all about map and route visualization in the following article.
And there you have it — you’ve successfully exported a GPX route/training file from Strava, parsed it with Python, and extracted key characteristics like latitude, longitude, and elevation. It’s just the tip of the iceberg, and you can expect to learn more applications of programming and data science in cycling in the upcoming articles.
Here’s a brief overview to get you motivated — I’ll add the URLs as I release the articles:
Article 1: Load and analyze GPX files from Strava
Article 2: Visualize GPX files from Strava with Folium — circle markers and polygon lines
Article 3: Calculate elevation difference and distance between points, visualize elevation profile of the route
Article 4: Calculate route gradients based on elevation difference and distance between points
Article 5: Calculate and visualize gradient profiles — distance cycled in gradient ranges
Article 6: Create a web application that analyzes and visualizes a user-uploaded GPX file from Strava
Thanks for reading, and stay tuned for more!
Loved the article? Become a Medium member to continue learning without limits. I’ll receive a portion of your membership fee if you use the following link, with no extra cost to you.
medium.com
Sign up for my newsletter
Subscribe on YouTube
Connect on LinkedIn